/*数组扩展*/
const { log } = console
// 1. 数组的扩展运算符
let f1 = () => {
  let arr = [1, 2, 3]
  let arr1 = ['a', 'b', 'c']
  let list = [...arr, ...arr1, ...'hello']
  console.log(list) // [ 1, 2, 3, 'a', 'b', 'c' ]
}
// f1()

// 2. 字符转数组
let f2 = () => {
  let str = 'hello'
  // let list = str.split('')
  // let list = [...str]
  let list = Array.from(str)
  console.log(list)
}
// f2()

// 3. 转换非数组结构的数据
let f3 = () => {
  let box = document.querySelectorAll('.box')
  console.log(box) // NodeList(4) 类数组，但不是数组，不能使用数组方法进行操作
  // let list = Array.from(box)
  // 由于NodeList接口实现了Iterator接口，所以可以使用扩展运行算符
  let list = [...box]
  list.forEach((item) => console.log(item))
}

// 4. 解构set map数据
let f4 = () => {
  let set = new Set([1, 2, 3])
  let map = new Map([
    ['a', 1],
    ['b', 2],
    ['c', 3],
  ])
  let list = [...set]
  log(list)
  // 解构map
  let mapList = [...map]
  log(mapList)
}

// 5. 数组构建的4种方式
let f5 = () => {
  let arr1 = [1, 2, 3, 4]
  let arr2 = new Array(1, 2, 3)
  let arr3 = Array.of(1, 2, 3)
  let box = document.querySelectorAll('.box')
  let arr4 = Array.from(box)
  arr4.forEach((item) => log(item))
}

// 6.  find()符合条件的元素， findIndex()符合条件的下标
let f6 = () => {
  let list = [1, 2, 3, 4, -1, 0, -2]
  // 找小于0的元素
  let el = list.find((item) => item < 0)
  log(el)
  // 找小于0元素的下标
  let index = list.findIndex((item) => item < 0)
  if (index !== -1) {
    log(list[index])
  }
}

// 7. 数组实例的 entries()，keys() 和 values()
let f7 = () => {
  let list = [5, 12, -3, 4, -1, 0, -2]
  // entries() 获得数组实体迭代器
  let entries = list.entries()
  for (let item of entries) {
    // console.log(item)
  }
  // keys()元素下标迭代器
  let keys = list.keys()
  for (let item of keys) {
    console.log(item)
  }
  // values()数组元素值迭代器
  let values = list.values()
  for (let item of values) {
    log(item)
  }
}
// f7()

// 8. 对象的entries()，keys() 和 values()
let f8 = () => {
  let stu = {
    id: 1,
    age: 20,
    gender: '女',
    name: 'wenddy',
    [Symbol]: 'hello',
  }
  // 对象的所有属性集合 不能遍历Symbol类型的属性
  // let keys = Object.keys(stu)
  let keys = Reflect.ownKeys(stu)
  for (let item of keys) {
    log(stu[item]) // 1, 20, '女', 'wenddy'
  }
  // 对象的所有属性值集合
  let values = Object.values(stu)
  log(values) // [ 1, 20, '女', 'wenddy' ]
  // 对象的entries
  let entries = Object.entries(stu)
  log(entries) // [ [ 'id', 1 ],  [ 'age', 20 ],  [ 'gender', '女' ],  [ 'name', 'wenddy' ] ]
}
// f8()

//  9. includes() 判断是否包含元素的方法
let f9 = () => {
  let list = [5, 12, -3, 4, -1, 0, -2]
  log(list.includes(-1)) // true
}
// f9()

// 10. [1, 2, [3, [4, 5]]].flat() 数组降维
let f10 = () => {
  let list = [1, 2, [3, [4, 5]]]
  let arr = list.flat(2)
  log(arr) // [1, 2, 3, 4, 5]
}
f10()

// 定义一个函数，传递一个数组，判断数组的维度是多少?如果数组不是一维数组，将数组转换为一维数组，不允许使用flat()
let task = (list) => {
  // 判断参数是否符合要求
  if (!Array.isArray(list)) {
    return log('list不是数组，无法求数组的维度')
  }
  // 定义一个空数组保存数组的元素
  let arr = []
  // 保存数组的维度
  let arr1 = []
  // 定义一个函数对数组的维度进行统计
  function f(list, dep = 0) {
    dep++
    // 把每一次的深度数放到arr1数组中
    arr1.push(dep)
    // 遍历所有的数组元素
    for (let item of list) {
      // 判断数组的元素是否是数组
      if (Array.isArray(item)) {
        // 是数组就对dep进行累加
        // 递归调用函数实现每层数组元素的遍历
        f(item, dep)
      } else {
        arr.push(item)
      }
    }
  }
  // 调用函数f,统计数组的维度，转换数组为一维数组
  f(list)
  // 求数组的最大值
  // function getMax(list) {
  //   let max = list[0]
  //   for (let item of list) {
  //     if (max < item) {
  //       max = item
  //     }
  //   }
  //   return max
  // }
  // let dim = getMax(arr1)
  let dim = Math.max.apply(null, arr1)
  // 定义一个变量，保存数组的维度
  return { dim, arr }
}
let rt = task([1, [2, [3, [4], [5, [6, [7, [8]]]]]], [3, [4, 5, [6, [7]]]]])
// let rt = task([1, [2], [3], [4, [5], [6, [7]]]])
console.log(rt)

let f = () => {}
f()
